home *** CD-ROM | disk | FTP | other *** search
/ IRIX 6.5 Applications 2002 November / SGI IRIX 6.5 Applications 2002 November.iso / dev / java2v131_02_dev.idb / usr / java2v131_02 / include / jvmpi.h.z / jvmpi.h
C/C++ Source or Header  |  2002-06-19  |  22KB  |  641 lines
  1. /*
  2.  * @(#)jvmpi.h    1.23 00/09/07
  3.  *
  4.  * Copyright 1997-2000 Sun Microsystems, Inc. All Rights Reserved.
  5.  * 
  6.  * This software is the proprietary information of Sun Microsystems, Inc.  
  7.  * Use is subject to license terms.
  8.  * 
  9.  */
  10.  
  11. #ifndef _JAVASOFT_JVMPI_H_
  12. #define _JAVASOFT_JVMPI_H_
  13.  
  14. #include "jni.h"
  15.  
  16. #define JVMPI_VERSION_1   ((jint)0x10000001)  /* implied 0 for minor version */
  17. #define JVMPI_VERSION_1_1 ((jint)0x10000002)
  18.  
  19. #ifdef __cplusplus
  20. extern "C" {
  21. #endif
  22.   typedef void (*jvmpi_void_function_of_void)(void *);
  23. #ifdef __cplusplus
  24. }
  25. #endif
  26.  
  27. /****************************************************************
  28.  * Profiler interface data structures.
  29.  ****************************************************************/
  30. /* identifier types. */
  31. struct _jobjectID;
  32. typedef struct _jobjectID * jobjectID;       /* type of object ids */ 
  33.  
  34. /* raw monitors */
  35. struct _JVMPI_RawMonitor;
  36. typedef struct _JVMPI_RawMonitor * JVMPI_RawMonitor;
  37.  
  38. /* call frame */
  39. typedef struct {
  40.     jint lineno;                      /* line number in the source file */
  41.     jmethodID method_id;              /* method executed in this frame */
  42. } JVMPI_CallFrame;
  43.  
  44. /* call trace */
  45. typedef struct {
  46.     JNIEnv *env_id;                   /* Env where trace was recorded */
  47.     jint num_frames;                  /* number of frames in this trace */
  48.     JVMPI_CallFrame *frames;          /* frames */
  49. } JVMPI_CallTrace;
  50.  
  51. /* method */
  52. typedef struct {
  53.     char *method_name;                /* name of method */
  54.     char *method_signature;           /* signature of method */
  55.     jint start_lineno;                /* -1 if native, abstract .. */
  56.     jint end_lineno;                  /* -1 if native, abstract .. */
  57.     jmethodID method_id;              /* id assigned to this method */
  58. } JVMPI_Method;
  59.  
  60. /* Field */
  61. typedef struct {
  62.     char *field_name;                 /* name of field */
  63.     char *field_signature;            /* signature of field */
  64. } JVMPI_Field;
  65.  
  66. /* line number info for a compiled method */
  67. typedef struct {
  68.     jint offset;                      /* offset from beginning of method */
  69.     jint lineno;                      /* lineno from beginning of src file */
  70. } JVMPI_Lineno;
  71.  
  72. /* event */
  73. typedef struct {
  74.     jint event_type;                  /* event_type */
  75.     JNIEnv *env_id;                   /* env where this event occured */
  76.   
  77.     union {
  78.         struct {
  79.         const char *class_name;   /* class name */
  80.         char *source_name;        /* name of source file */
  81.         jint num_interfaces;      /* number of interfaces implemented */
  82.           jint num_methods;         /* number of methods in the class */
  83.         JVMPI_Method *methods;    /* methods */
  84.         jint num_static_fields;   /* number of static fields */
  85.         JVMPI_Field *statics;     /* static fields */
  86.         jint num_instance_fields; /* number of instance fields */
  87.         JVMPI_Field *instances;   /* instance fields */
  88.         jobjectID class_id;       /* id of the class object */
  89.     } class_load;
  90.  
  91.         struct {
  92.         jobjectID class_id;       /* id of the class object */
  93.     } class_unload;
  94.  
  95.         struct {
  96.         unsigned char *class_data;        /* content of class file */
  97.         jint class_data_len;              /* class file length */
  98.         unsigned char *new_class_data;    /* instrumented class file */
  99.         jint new_class_data_len;          /* new class file length */
  100.         void * (*malloc_f)(unsigned int); /* memory allocation function */
  101.     } class_load_hook;
  102.  
  103.         struct {
  104.             jint arena_id;
  105.         jobjectID class_id;       /* id of object class */
  106.         jint is_array;            /* JVMPI_NORMAL_OBJECT, ... */
  107.         jint size;                /* size in number of bytes */
  108.         jobjectID obj_id;         /* id assigned to this object */
  109.         } obj_alloc;
  110.  
  111.         struct {
  112.         jobjectID obj_id;         /* id of the object */
  113.     } obj_free;
  114.  
  115.         struct {
  116.         jint arena_id;            /* cur arena id */
  117.         jobjectID obj_id;         /* cur object id */
  118.         jint new_arena_id;        /* new arena id */
  119.         jobjectID new_obj_id;     /* new object id */      
  120.     } obj_move;
  121.  
  122.         struct {
  123.         jint arena_id;            /* id of arena */
  124.         const char *arena_name;   /* name of arena */
  125.     } new_arena;
  126.  
  127.         struct {
  128.         jint arena_id;            /* id of arena */
  129.     } delete_arena;
  130.  
  131.         struct {
  132.         char *thread_name;        /* name of thread */
  133.         char *group_name;         /* name of group */
  134.         char *parent_name;        /* name of parent */
  135.         jobjectID thread_id;      /* id of the thread object */
  136.         JNIEnv *thread_env_id;
  137.         } thread_start;
  138.  
  139.         struct {
  140.         int dump_level;           /* level of the heap dump info */
  141.         char *begin;              /* where all the root records begin,
  142.                      please see the heap dump buffer 
  143.                          format described below */
  144.         char *end;                /* where the object records end. */
  145.         jint num_traces;          /* number of thread traces, 
  146.                          0 if dump level = JVMPI_DUMP_LEVEL_0 */
  147.         JVMPI_CallTrace *traces;  /* thread traces collected during 
  148.                      heap dump */ 
  149.     } heap_dump;
  150.  
  151.         struct {
  152.         jobjectID obj_id;         /* object id */
  153.         jobject ref_id;           /* id assigned to the globalref */
  154.     } jni_globalref_alloc;
  155.       
  156.         struct {
  157.         jobject ref_id;           /* id of the global ref */
  158.     } jni_globalref_free;
  159.  
  160.         struct {
  161.         jmethodID method_id;      /* method */
  162.     } method;
  163.  
  164.         struct {
  165.         jmethodID method_id;      /* id of method */
  166.         jobjectID obj_id;         /* id of target object */
  167.     } method_entry2;
  168.  
  169.         struct {
  170.         jmethodID method_id;        /* id of compiled method */
  171.         void *code_addr;            /* code start addr. in memory */
  172.         jint code_size;             /* code size */
  173.         jint lineno_table_size;     /* size of lineno table */
  174.         JVMPI_Lineno *lineno_table; /* lineno info */
  175.     } compiled_method_load;
  176.         
  177.         struct {
  178.         jmethodID method_id;        /* id of unloaded compiled method */
  179.     } compiled_method_unload;
  180.  
  181.     struct {
  182.         jmethodID method_id; /* id of the method the instruction belongs to */
  183.         jint offset;         /* instruction offset in the method's bytecode */
  184.         union {
  185.         struct {
  186.             jboolean is_true; /* whether true or false branch is taken  */
  187.         } if_info;
  188.         struct {
  189.             jint key; /* top stack value used as an index */
  190.             jint low; /* min value of the index           */
  191.             jint hi;  /* max value of the index           */
  192.         } tableswitch_info;
  193.         struct {
  194.             jint chosen_pair_index; /* actually chosen pair index (0-based)
  195.                                              * if chosen_pair_index == pairs_total then
  196.                                              * the 'default' branch is taken
  197.                                              */
  198.             jint pairs_total;       /* total number of lookupswitch pairs */
  199.         } lookupswitch_info;
  200.         } u;
  201.     } instruction;
  202.     
  203.         struct {
  204.         char *begin;                /* beginning of dump buffer, 
  205.                        see below for format */
  206.         char *end;                  /* end of dump buffer */
  207.         jint num_traces;            /* number of traces */
  208.         JVMPI_CallTrace *traces;    /* traces of all threads */
  209.         jint *threads_status;       /* status of all threads */
  210.     } monitor_dump;
  211.  
  212.         struct {
  213.         const char *name;           /* name of raw monitor */
  214.         JVMPI_RawMonitor id;        /* id */
  215.     } raw_monitor;
  216.  
  217.         struct {
  218.         jobjectID object;           /* Java object */
  219.     } monitor;
  220.  
  221.         struct {
  222.         jobjectID object;           /* Java object */
  223.         jlong timeout;              /* timeout period */
  224.     } monitor_wait;
  225.  
  226.         struct {
  227.         jlong used_objects;
  228.         jlong used_object_space;
  229.         jlong total_object_space;
  230.     } gc_info;
  231.  
  232.         struct {
  233.         jint data_len;
  234.         char *data;
  235.     } object_dump;
  236.     } u;
  237. } JVMPI_Event;
  238.  
  239. /* interface functions */
  240. typedef struct {
  241.     jint version;   /* JVMPI version */
  242.     
  243.     /* ------interface implemented by the profiler------ */
  244.  
  245.     /**
  246.      * Function called by the JVM to notify an event. 
  247.      */
  248.     void (*NotifyEvent)(JVMPI_Event *event);
  249.   
  250.     /* ------interface implemented by the JVM------ */
  251.     
  252.     /**
  253.      * Function called by the profiler to enable/disable/send notification 
  254.      * for a particular event type.  
  255.      * 
  256.      * event_type - event_type
  257.      * arg - event specific arg
  258.      *
  259.      * return JVMPI_NOT_AVAILABLE, JVMPI_SUCCESS or JVMPI_FAIL
  260.      */
  261.     jint (*EnableEvent)(jint event_type, void *arg);
  262.     jint (*DisableEvent)(jint event_type, void *arg);
  263.     jint (*RequestEvent)(jint event_type, void *arg);
  264.   
  265.     /**
  266.      * Function called by the profiler to get a stack
  267.      * trace from the JVM.
  268.      *
  269.      * trace - trace data structure to be filled
  270.      * depth - maximum depth of the trace.
  271.      */
  272.     void (*GetCallTrace)(JVMPI_CallTrace *trace, jint depth);
  273.  
  274.     /**
  275.      * Function called by profiler when it wants to exit/stop.
  276.      */
  277.     void (*ProfilerExit)(jint);
  278.  
  279.     /**
  280.      * Utility functions provided by the JVM.
  281.      */
  282.     JVMPI_RawMonitor (*RawMonitorCreate)(char *lock_name);
  283.     void (*RawMonitorEnter)(JVMPI_RawMonitor lock_id);
  284.     void (*RawMonitorExit)(JVMPI_RawMonitor lock_id);
  285.     void (*RawMonitorWait)(JVMPI_RawMonitor lock_id, jlong ms);
  286.     void (*RawMonitorNotifyAll)(JVMPI_RawMonitor lock_id);
  287.     void (*RawMonitorDestroy)(JVMPI_RawMonitor lock_id);
  288.  
  289.     /**
  290.      * Function called by the profiler to get the current thread's CPU time.
  291.      *
  292.      * return time in nanoseconds;
  293.      */
  294.     jlong (*GetCurrentThreadCpuTime)(void);
  295.  
  296.     void (*SuspendThread)(JNIEnv *env);
  297.     void (*ResumeThread)(JNIEnv *env);
  298.     jint (*GetThreadStatus)(JNIEnv *env);
  299.     jboolean (*ThreadHasRun)(JNIEnv *env);
  300.  
  301.     /* This function can be called safely only after JVMPI_EVENT_VM_INIT_DONE
  302.        notification by the JVM. */
  303.     jint (*CreateSystemThread)(char *name, jint priority, void (*f)(void *));
  304.  
  305.     /* thread local storage access functions to avoid locking in time 
  306.        critical functions */
  307.     void (*SetThreadLocalStorage)(JNIEnv *env_id, void *ptr);
  308.     void * (*GetThreadLocalStorage)(JNIEnv *env_id);
  309.  
  310.     /* control GC */
  311.     void (*DisableGC)(void);
  312.     void (*EnableGC)(void);
  313.     void (*RunGC)(void);
  314.  
  315.     jobjectID (*GetThreadObject)(JNIEnv *env);
  316.     jobjectID (*GetMethodClass)(jmethodID mid);
  317.  
  318.     /* JNI <-> jobject conversions */
  319.     jobject   (*jobjectID2jobject)(jobjectID jid);
  320.     jobjectID (*jobject2jobjectID)(jobject jobj);
  321.  
  322. } JVMPI_Interface;
  323.  
  324. /* type of argument passed to RequestEvent for heap dumps */
  325. typedef struct {
  326.     jint heap_dump_level;
  327. } JVMPI_HeapDumpArg;
  328.  
  329. /**********************************************************************
  330.  * Constants and formats used in JVM Profiler Interface.
  331.  **********************************************************************/
  332. /*
  333.  * Event type constants.
  334.  */
  335. #define JVMPI_EVENT_METHOD_ENTRY            ((jint)1) 
  336. #define JVMPI_EVENT_METHOD_ENTRY2           ((jint)2) 
  337. #define JVMPI_EVENT_METHOD_EXIT             ((jint)3) 
  338.  
  339. #define JVMPI_EVENT_OBJECT_ALLOC            ((jint)4) 
  340. #define JVMPI_EVENT_OBJECT_FREE             ((jint)5) 
  341. #define JVMPI_EVENT_OBJECT_MOVE             ((jint)6) 
  342.  
  343. #define JVMPI_EVENT_COMPILED_METHOD_LOAD    ((jint)7) 
  344. #define JVMPI_EVENT_COMPILED_METHOD_UNLOAD  ((jint)8) 
  345.  
  346. #define JVMPI_EVENT_INSTRUCTION_START       ((jint)9) 
  347.  
  348. #define JVMPI_EVENT_THREAD_START           ((jint)33) 
  349. #define JVMPI_EVENT_THREAD_END             ((jint)34) 
  350.  
  351. #define JVMPI_EVENT_CLASS_LOAD_HOOK        ((jint)35) 
  352.  
  353. #define JVMPI_EVENT_HEAP_DUMP                     ((jint)37) 
  354. #define JVMPI_EVENT_JNI_GLOBALREF_ALLOC           ((jint)38) 
  355. #define JVMPI_EVENT_JNI_GLOBALREF_FREE            ((jint)39) 
  356. #define JVMPI_EVENT_JNI_WEAK_GLOBALREF_ALLOC      ((jint)40) 
  357. #define JVMPI_EVENT_JNI_WEAK_GLOBALREF_FREE       ((jint)41) 
  358. #define JVMPI_EVENT_CLASS_LOAD                    ((jint)42) 
  359. #define JVMPI_EVENT_CLASS_UNLOAD                  ((jint)43) 
  360. #define JVMPI_EVENT_DATA_DUMP_REQUEST             ((jint)44) 
  361. #define JVMPI_EVENT_DATA_RESET_REQUEST            ((jint)45) 
  362.  
  363. #define JVMPI_EVENT_JVM_INIT_DONE          ((jint)46) 
  364. #define JVMPI_EVENT_JVM_SHUT_DOWN          ((jint)47) 
  365.  
  366. #define JVMPI_EVENT_ARENA_NEW              ((jint)48)
  367. #define JVMPI_EVENT_ARENA_DELETE           ((jint)49)
  368.  
  369. #define JVMPI_EVENT_OBJECT_DUMP            ((jint)50)
  370.  
  371. #define JVMPI_EVENT_RAW_MONITOR_CONTENDED_ENTER   ((jint)51)
  372. #define JVMPI_EVENT_RAW_MONITOR_CONTENDED_ENTERED ((jint)52)
  373. #define JVMPI_EVENT_RAW_MONITOR_CONTENDED_EXIT    ((jint)53)
  374. #define JVMPI_EVENT_MONITOR_CONTENDED_ENTER       ((jint)54)
  375. #define JVMPI_EVENT_MONITOR_CONTENDED_ENTERED     ((jint)55)
  376. #define JVMPI_EVENT_MONITOR_CONTENDED_EXIT        ((jint)56)
  377. #define JVMPI_EVENT_MONITOR_WAIT                  ((jint)57)
  378. #define JVMPI_EVENT_MONITOR_WAITED                ((jint)58)
  379. #define JVMPI_EVENT_MONITOR_DUMP                  ((jint)59)
  380.  
  381. #define JVMPI_EVENT_GC_START                      ((jint)60)
  382. #define JVMPI_EVENT_GC_FINISH                     ((jint)61)
  383.  
  384. #define JVMPI_MAX_EVENT_TYPE_VAL                  ((jint)61)
  385.  
  386. /* old definitions, to be removed */
  387. #define JVMPI_EVENT_LOAD_COMPILED_METHOD          ((jint)7) 
  388. #define JVMPI_EVENT_UNLOAD_COMPILED_METHOD        ((jint)8) 
  389. #define JVMPI_EVENT_NEW_ARENA                     ((jint)48)
  390. #define JVMPI_EVENT_DELETE_ARENA                  ((jint)49)
  391. #define JVMPI_EVENT_DUMP_DATA_REQUEST             ((jint)44) 
  392. #define JVMPI_EVENT_RESET_DATA_REQUEST            ((jint)45) 
  393. #define JVMPI_EVENT_OBJ_ALLOC                     ((jint)4) 
  394. #define JVMPI_EVENT_OBJ_FREE                      ((jint)5) 
  395. #define JVMPI_EVENT_OBJ_MOVE                      ((jint)6) 
  396.  
  397. #define JVMPI_REQUESTED_EVENT                     ((jint)0x10000000)
  398.  
  399.  
  400.  
  401. /* 
  402.  * enabling/disabling event notification.
  403.  */
  404. /* results */
  405. #define JVMPI_SUCCESS                    ((jint)0)
  406. #define JVMPI_NOT_AVAILABLE              ((jint)1)
  407. #define JVMPI_FAIL                       ((jint)-1)
  408.  
  409. /*
  410.  * Thread status
  411.  */
  412. enum {
  413.     JVMPI_THREAD_RUNNABLE = 1,
  414.     JVMPI_THREAD_MONITOR_WAIT,
  415.     JVMPI_THREAD_CONDVAR_WAIT
  416. };
  417.  
  418. #define JVMPI_THREAD_SUSPENDED        0x8000
  419. #define JVMPI_THREAD_INTERRUPTED      0x4000
  420.  
  421. /*
  422.  * Thread priority
  423.  */
  424. #define JVMPI_MINIMUM_PRIORITY        1
  425. #define JVMPI_MAXIMUM_PRIORITY        10
  426. #define JVMPI_NORMAL_PRIORITY        5
  427.  
  428. /*
  429.  * Object type constants.
  430.  */
  431. #define JVMPI_NORMAL_OBJECT             ((jint)0)
  432. #define JVMPI_CLASS                 ((jint)2)
  433. #define JVMPI_BOOLEAN                     ((jint)4)
  434. #define JVMPI_CHAR                       ((jint)5)
  435. #define JVMPI_FLOAT                      ((jint)6)
  436. #define JVMPI_DOUBLE                     ((jint)7)
  437. #define JVMPI_BYTE                       ((jint)8)
  438. #define JVMPI_SHORT                      ((jint)9)
  439. #define JVMPI_INT                        ((jint)10)
  440. #define JVMPI_LONG                       ((jint)11)    
  441.  
  442. /*
  443.  * Monitor dump constants.
  444.  */
  445.  
  446. #define JVMPI_MONITOR_JAVA          0x01
  447. #define JVMPI_MONITOR_RAW           0x02
  448.  
  449. /*
  450.  * Heap dump constants.
  451.  */
  452. #define JVMPI_GC_ROOT_UNKNOWN       0xff
  453. #define JVMPI_GC_ROOT_JNI_GLOBAL    0x01
  454. #define JVMPI_GC_ROOT_JNI_LOCAL     0x02
  455. #define JVMPI_GC_ROOT_JAVA_FRAME    0x03
  456. #define JVMPI_GC_ROOT_NATIVE_STACK  0x04
  457. #define JVMPI_GC_ROOT_STICKY_CLASS  0x05
  458. #define JVMPI_GC_ROOT_THREAD_BLOCK  0x06
  459. #define JVMPI_GC_ROOT_MONITOR_USED  0x07
  460. #define JVMPI_GC_ROOT_THREAD_OBJ    0x08
  461.  
  462. #define JVMPI_GC_CLASS_DUMP         0x20
  463. #define JVMPI_GC_INSTANCE_DUMP      0x21 
  464. #define JVMPI_GC_OBJ_ARRAY_DUMP     0x22
  465. #define JVMPI_GC_PRIM_ARRAY_DUMP    0x23
  466.  
  467. /*
  468.  * Dump levels
  469.  */
  470. #define JVMPI_DUMP_LEVEL_0    ((jint)0)
  471. #define JVMPI_DUMP_LEVEL_1    ((jint)1)
  472. #define JVMPI_DUMP_LEVEL_2    ((jint)2)
  473.  
  474. /* Types used in dumps -
  475.  *
  476.  * u1: 1 byte
  477.  * u2: 2 bytes
  478.  * u4: 4 bytes
  479.  * u8: 8 bytes
  480.  *
  481.  * ty: u1 where:
  482.  *     JVMPI_CLASS:   object
  483.  *     JVMPI_BOOLEAN: boolean
  484.  *     JVMPI_CHAR:    char
  485.  *     JVMPI_FLOAT:   float
  486.  *     JVMPI_DOUBLE:  double
  487.  *     JVMPI_BYTE:    byte
  488.  *     JVMPI_SHORT:   short
  489.  *     JVMPI_INT:     int
  490.  *     JVMPI_LONG:    long
  491.  *
  492.  * vl: values, exact type depends on the type of the value:
  493.  *     JVMPI_BOOLEAN & JVMPI_BYTE:   u1
  494.  *     JVMPI_SHORT & JVMPI_CHAR:     u2
  495.  *     JVMPI_INT & JVMPI_FLOAT:      u4
  496.  *     JVMPI_LONG & JVMPI_DOUBLE:    u8
  497.  *     JVMPI_CLASS:                  jobjectID
  498.  */
  499.  
  500. /* Format of the monitor dump buffer:
  501.  *
  502.  *               u1                          monitor type
  503.  *
  504.  *               JVMPI_MONITOR_JAVA          Java monitor
  505.  *
  506.  *                          jobjectID        object
  507.  *                          JNIEnv *         owner thread
  508.  *                          u4               entry count
  509.  *                          u4               # of threads waiting to enter
  510.  *                          [JNIEnv *]*      threads waiting to enter
  511.  *                          u4               # of threads waiting to be notified
  512.  *                          [JNIEnv *]*      threads waiting to be notified
  513.  *
  514.  *               JVMPI_MONITOR_RAW           raw monitor
  515.  *
  516.  *                          char *           name
  517.  *                          JVMPI_RawMonitor raw monitor
  518.  *                          JNIEnv *         owner thread
  519.  *                          u4               entry count
  520.  *                          u4               # of threads waiting to enter
  521.  *                          [JNIEnv *]*      threads waiting to enter
  522.  *                          u4               # of threads waiting to be notified
  523.  *                          [JNIEnv *]*      threads waiting to be notified
  524.  */
  525.  
  526. /* Format of the heap dump buffer depends on the dump level 
  527.  * specified in the JVMPI_HeapDumpArg passed to RequestEvent as arg. 
  528.  * The default is JVMPI_DUMP_LEVEL_2.
  529.  *
  530.  * JVMPI_DUMP_LEVEL_0:
  531.  * 
  532.  *               u1                          object type (JVMPI_CLASS ...)
  533.  *               jobjectID                   object
  534.  *
  535.  * JVMPI_DUMP_LEVEL_1 and JVMPI_DUMP_LEVEL_2 use the following format:  
  536.  * In the case of JVMPI_DUMP_LEVEL_1 the values of primitive fields in object 
  537.  * instance dumps , the values of primitive statics in class dumps and the 
  538.  * values of primitive arrays are excluded.  JVMPI_DUMP_LEVEL_2 includes the
  539.  * primitive values.
  540.  *
  541.  *               u1                          record type
  542.  *
  543.  *               JVMPI_GC_ROOT_UNKNOWN       unknown root
  544.  *
  545.  *                          jobjectID        object
  546.  *
  547.  *               JVMPI_GC_ROOT_JNI_GLOBAL    JNI global ref root
  548.  *
  549.  *                          jobjectID        object
  550.  *                          jobject          JNI global reference
  551.  *
  552.  *               JVMPI_GC_ROOT_JNI_LOCAL     JNI local ref
  553.  *
  554.  *                          jobjectID        object
  555.  *                          JNIEnv *         thread
  556.  *                          u4               frame # in stack trace (-1 for empty)
  557.  *
  558.  *               JVMPI_GC_ROOT_JAVA_FRAME    Java stack frame
  559.  *
  560.  *                          jobjectID        object
  561.  *                          JNIEnv *         thread
  562.  *                          u4               frame # in stack trace (-1 for empty)
  563.  *
  564.  *               JVMPI_GC_ROOT_NATIVE_STACK  Native stack
  565.  *
  566.  *                          jobjectID        object
  567.  *                          JNIEnv *         thread
  568.  *
  569.  *               JVMPI_GC_ROOT_STICKY_CLASS  System class
  570.  *
  571.  *                          jobjectID        class object
  572.  *
  573.  *               JVMPI_GC_ROOT_THREAD_BLOCK  Reference from thread block
  574.  *
  575.  *                          jobjectID        thread object
  576.  *                          JNIEnv *         thread
  577.  *
  578.  *               JVMPI_GC_ROOT_MONITOR_USED  Busy monitor
  579.  *
  580.  *                          jobjectID        object
  581.  *
  582.  *               JVMPI_GC_CLASS_DUMP         dump of a class object
  583.  *
  584.  *                          jobjectID        class
  585.  *                          jobjectID        super
  586.  *                          jobjectID        class loader
  587.  *                          jobjectID        signers
  588.  *                          jobjectID        protection domain
  589.  *                          jobjectID        class name
  590.  *                          void *           reserved
  591.  *
  592.  *                          u4               instance size (in bytes)
  593.  *
  594.  *                          [jobjectID]*     interfaces
  595.  *
  596.  *                          u2               size of constant pool
  597.  *                          [u2,             constant pool index,
  598.  *                           ty,             type, 
  599.  *                           vl]*            value
  600.  *
  601.  *                          [vl]*            static field values
  602.  *
  603.  *               JVMPI_GC_INSTANCE_DUMP      dump of a normal object
  604.  *
  605.  *                          jobjectID        object
  606.  *                          jobjectID        class
  607.  *                          u4               number of bytes that follow
  608.  *                          [vl]*            instance field values (class, followed
  609.  *                                           by super, super's super ...)
  610.  *
  611.  *               JVMPI_GC_OBJ_ARRAY_DUMP     dump of an object array
  612.  *
  613.  *                          jobjectID        array object
  614.  *                          u4               number of elements
  615.  *                          jobjectID        element class
  616.  *                          [jobjectID]*     elements
  617.  *
  618.  *               JVMPI_GC_PRIM_ARRAY_DUMP    dump of a primitive array
  619.  *
  620.  *                          jobjectID        array object
  621.  *                          u4               number of elements
  622.  *                          ty               element type
  623.  *                          [vl]*            elements
  624.  *
  625.  */
  626.  
  627. /* Format of the dump received in JVMPI_EVENT_OBJECT_DUMP:
  628.  * All the records have JVMPI_DUMP_LEVEL_2 information.
  629.  *
  630.  *               u1                          record type
  631.  *
  632.  *                     followed by a:
  633.  *
  634.  *                          JVMPI_GC_CLASS_DUMP,
  635.  *                          JVMPI_GC_INSTANCE_DUMP,
  636.  *                          JVMPI_GC_OBJ_ARRAY_DUMP, or
  637.  *                          JVMPI_GC_PRIM_ARRAY_DUMP record.
  638.  */
  639.  
  640. #endif /* !_JAVASOFT_JVMPI_H_ */
  641.